/**
 * @desc 函数防抖
 * @param func 函数
 * @param wait 延迟执行毫秒数
 * @param immediate true 表立即执行，false 表非立即执行
 */
// 函数防抖
function debounce(func, wait, immediate) {
    // 定义定时器
    let timeout;
    // 返回一个函数
    return function () {
        // 获取当前上下文
        const context = this;
        // 获取参数
        const args = [...arguments];
        // 如果定时器存在，清除定时器
        if (timeout) clearTimeout(timeout);
        // 如果立即执行，就立即执行函数
        if (immediate) {
            const callNow = !timeout;
            // 设置定时器，执行函数
            timeout = setTimeout(() => {
                timeout = null;
            }, wait)
            // 如果立即执行，就调用函数
            if (callNow) func.apply(context, args)
        }
        // 否则，设置定时器，执行函数
        else {
            timeout = setTimeout(() => {
                func.apply(context, args)
            }, wait);
        }
    }
}


/**
 * @desc 函数节流
 * @param func 函数
 * @param wait 延迟执行毫秒数
 * @param type 1 表时间戳版，2 表定时器版
 */
function throttle(func, wait ,type) {
    if(type===1){
        let previous = 0;
    }else if(type===2){
        let timeout;
    }
    return function() {
        let context = this;
        let args = arguments;
        if(type===1){
            let now = Date.now();

            if (now - previous > wait) {
                func.apply(context, args);
                previous = now;
            }
        }else if(type===2){
            if (!timeout) {
                timeout = setTimeout(() => {
                    timeout = null;
                    func.apply(context, args)
                }, wait)
            }
        }

    }
}
// 注释一下  
/**
 * 函数节流
 * @param {Function} func 要节流的函数
 * @param {number} wait 延迟执行的时间间隔（毫秒）
 * @param {number} type 节流类型：1 表示时间戳版，2 表示定时器版
 * @returns {Function} 返回一个节流后的函数
 */
function throttle(func, wait, type) {
    // 根据节流类型选择不同的变量进行初始化
    if (type === 1) {
        let previous = 0; // 用于时间戳版节流的上一次执行时间记录
    } else if (type === 2) {
        let timeout; // 用于定时器版节流的定时器句柄
    }

    // 返回一个节流函数
    return function() {
        let context = this; // 函数执行的上下文
        let args = arguments; // 函数接收的参数

        // 根据节流类型选择不同的节流逻辑
        if (type === 1) {
            let now = Date.now(); // 获取当前时间戳
            // 当当前时间与上一次执行时间间隔大于指定时间间隔时执行函数，并更新上一次执行时间
            if (now - previous > wait) {
                func.apply(context, args);
                previous = now;
            }
        } else if (type === 2) {
            // 如果定时器未设置，则设置一个定时器，在指定时间间隔后执行函数
            if (!timeout) {
                timeout = setTimeout(() => {
                    timeout = null;
                    func.apply(context, args)
                }, wait)
            }
        }
    }
}
